<html>
<head><meta charset="utf-8"><title>impl trait vs explicit trait bounds · wg-traits · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/index.html">wg-traits</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html">impl trait vs explicit trait bounds</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="217696229"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217696229" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Noah Lev <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217696229">(Nov 23 2020 at 23:15)</a>:</h4>
<p>Is there any semantic difference between <code>impl Trait</code> and <code>&lt;T: Trait&gt; T</code>?</p>
<p>For example:</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">fn</span> <span class="nf">read</span><span class="p">(</span><span class="n">reader</span>: <span class="kp">&amp;</span><span class="nc">mut</span><span class="w"> </span><span class="k">impl</span><span class="w"> </span><span class="n">io</span>::<span class="n">Read</span><span class="p">);</span><span class="w"></span>
<span class="c1">// vs.</span>
<span class="k">fn</span> <span class="nf">read</span><span class="o">&lt;</span><span class="n">R</span>: <span class="nc">io</span>::<span class="n">Read</span><span class="o">&gt;</span><span class="p">(</span><span class="n">reader</span>: <span class="kp">&amp;</span><span class="nc">mut</span><span class="w"> </span><span class="n">R</span><span class="p">);</span><span class="w"></span>
<span class="c1">// vs. (though I think this is the same as &lt;R: io::Read&gt;)</span>
<span class="k">fn</span> <span class="nf">read</span><span class="o">&lt;</span><span class="n">R</span><span class="o">&gt;</span><span class="p">(</span><span class="n">reader</span>: <span class="kp">&amp;</span><span class="nc">mut</span><span class="w"> </span><span class="n">R</span><span class="p">)</span><span class="w"> </span><span class="k">where</span><span class="w"> </span><span class="n">R</span>: <span class="nc">io</span>::<span class="n">Read</span><span class="p">;</span><span class="w"></span>
</code></pre></div>



<a name="217696874"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217696874" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217696874">(Nov 23 2020 at 23:23)</a>:</h4>
<p>2 and 3 are the same afaik</p>



<a name="217696892"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217696892" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217696892">(Nov 23 2020 at 23:23)</a>:</h4>
<p>there are some subtle differences between 1 and 2 though</p>



<a name="217696976"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217696976" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217696976">(Nov 23 2020 at 23:24)</a>:</h4>
<p>you can't name <code>R</code> for <code>impl io::Read</code>, so <code>read::&lt;SpecificReader&gt;(...)</code> does not work for 1</p>



<a name="217697046"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217697046" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217697046">(Nov 23 2020 at 23:25)</a>:</h4>
<p>other than that we should just lower argument position <code>impl Trait</code> to a param. I am not completely sure about that though</p>



<a name="217697200"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217697200" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Noah Lev <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217697200">(Nov 23 2020 at 23:27)</a>:</h4>
<p>Thanks! What happens to return position <code>impl Trait</code> that's different from argument position?</p>



<a name="217697237"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217697237" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Noah Lev <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217697237">(Nov 23 2020 at 23:27)</a>:</h4>
<p><span class="user-mention silent" data-user-id="216206">lcnr</span> <a href="#narrow/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds/near/217696976">said</a>:</p>
<blockquote>
<p>you can't name <code>R</code> for <code>impl io::Read</code>, so <code>read::&lt;SpecificReader&gt;(...)</code> does not work for 1</p>
</blockquote>
<p>Though you could probably accomplish the same with</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="kd">let</span><span class="w"> </span><span class="n">reader</span>: <span class="nc">SpecificReader</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="cm">/* ... */</span><span class="p">;</span><span class="w"></span>
<span class="n">read</span><span class="p">(</span><span class="n">reader</span><span class="p">);</span><span class="w"></span>
</code></pre></div>
<p>right?</p>



<a name="217697628"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217697628" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217697628">(Nov 23 2020 at 23:32)</a>:</h4>
<p>Using <code>impl Trait</code> in argument position also prevent callers from explicitly specifying <em>any</em> explicit type parameters</p>



<a name="217697673"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217697673" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217697673">(Nov 23 2020 at 23:33)</a>:</h4>
<p>return position impl trait is a different language feature (an "existential type" determined by the function declaring it, not the caller)</p>



<a name="217923592"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/217923592" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#217923592">(Nov 25 2020 at 18:43)</a>:</h4>
<p><span class="user-mention silent" data-user-id="211727">Jonas Schievink</span> <a href="#narrow/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds/near/217697628">said</a>:</p>
<blockquote>
<p>Using <code>impl Trait</code> in argument position also prevent callers from explicitly specifying <em>any</em> explicit type parameters</p>
</blockquote>
<p>this is not really intended as a long-term solution though</p>



<a name="245964267"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245964267" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245964267">(Jul 14 2021 at 14:07)</a>:</h4>
<p>I'm a bit confused with the syntax here, I have:</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">pub</span><span class="w"> </span><span class="k">trait</span><span class="w"> </span><span class="n">Handler</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">Error</span>: <span class="nc">crate</span>::<span class="n">error</span>::<span class="n">Error</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nb">From</span><span class="o">&lt;</span><span class="n">Error</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>

<span class="w">    </span><span class="k">fn</span> <span class="nf">handle</span><span class="p">(</span><span class="o">&amp;</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">message</span>: <span class="nc">impl</span><span class="w"> </span><span class="n">Msg</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nb">Result</span><span class="o">&lt;</span><span class="p">(),</span><span class="w"> </span><span class="bp">Self</span>::<span class="n">Error</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>

<span class="w">    </span><span class="k">fn</span> <span class="nf">handle_err</span><span class="p">(</span><span class="o">&amp;</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">error</span>: <span class="nc">Self</span>::<span class="n">Error</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nb">Result</span><span class="o">&lt;</span><span class="p">(),</span><span class="w"> </span><span class="bp">Self</span>::<span class="n">Error</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>
<p>when I <code>impl Handler for X</code>, replacing the input argument <code>impl Msg</code> by a struct that implements Msg trait,  I get <code>method handle has 0 type parameters but its trait declaration has 1 type parameter</code></p>



<a name="245964593"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245964593" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245964593">(Jul 14 2021 at 14:09)</a>:</h4>
<p><code>impl Msg</code> as a function arg means something like <code>T: Msg</code>, without naming <code>T</code></p>



<a name="245964895"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245964895" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245964895">(Jul 14 2021 at 14:10)</a>:</h4>
<p>what do I have to do when implementing the handle fn of this trait?</p>



<a name="245965140"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965140" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965140">(Jul 14 2021 at 14:12)</a>:</h4>
<p>how should i pass the type parameter?</p>



<a name="245965192"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965192" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965192">(Jul 14 2021 at 14:12)</a>:</h4>
<p>as i said, i was passing a struct that impl Msg, but that doesnt work</p>



<a name="245965263"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965263" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965263">(Jul 14 2021 at 14:13)</a>:</h4>
<p>I mean, what exactly is your intention? Do you want handle to be able to take any Msg for a given impl, and <em>all</em> messages for a given impl</p>



<a name="245965264"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965264" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965264">(Jul 14 2021 at 14:13)</a>:</h4>
<p><code>error    E0049  method </code>handle<code> has 0 type parameters but its trait declaration has 1 type parameter
 found 0 type parameters, expected 1 (lsp)</code></p>



<a name="245965462"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965462" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965462">(Jul 14 2021 at 14:14)</a>:</h4>
<p>The intention of the implementer of the trait is to hard-code a type</p>



<a name="245965463"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965463" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965463">(Jul 14 2021 at 14:14)</a>:</h4>
<p>If it's the former, the signature of the function stays the same in simple. (Alternatively, you could change the function to use a generic)</p>



<a name="245965593"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245965593" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245965593">(Jul 14 2021 at 14:15)</a>:</h4>
<p>If it's the latter, you want a new associated type <code>MyMsg: Msg</code> and the function signature would then take a <code>Self::MyMsg</code></p>



<a name="245966367"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245966367" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245966367">(Jul 14 2021 at 14:20)</a>:</h4>
<p><span class="user-mention silent" data-user-id="232957">Jack Huey</span> <a href="#narrow/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds/near/245965263">said</a>:</p>
<blockquote>
<p>I mean, what exactly is your intention? Do you want handle to be able to take any Msg for a given impl, and <em>all</em> messages for a given impl</p>
</blockquote>
<p>former meaning -&gt; take any Msg for a given impl</p>
<p>latter -&gt; <em>all</em> messages for a given impl</p>
<p>Im afraid I dont clearly see the difference here<br>
<span class="user-mention" data-user-id="232957">@Jack Huey</span></p>



<a name="245966524"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245966524" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245966524">(Jul 14 2021 at 14:21)</a>:</h4>
<p>Ah sorry, typo. I meant a single given message for the latter</p>



<a name="245967511"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245967511" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245967511">(Jul 14 2021 at 14:28)</a>:</h4>
<p>my intention was the Handler trait definition to allow for anything implementing Msg, thus former. </p>
<p>So if I'm understanding this right, the impl of the trait Handler must have a <code>impl Msg</code> as input argument type, and not pass any concrete type, is that correct?</p>



<a name="245967653"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245967653" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245967653">(Jul 14 2021 at 14:29)</a>:</h4>
<p>Well, it would have <code>impl Msg</code> as an arg, but you definitely can pass a concrete type (because of monomorphization)</p>



<a name="245967837"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245967837" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245967837">(Jul 14 2021 at 14:30)</a>:</h4>
<p>but the function signature must contain <code>impl Msg</code></p>



<a name="245967860"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245967860" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245967860">(Jul 14 2021 at 14:31)</a>:</h4>
<p>Yes</p>



<a name="245967897"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245967897" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> zkao <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245967897">(Jul 14 2021 at 14:31)</a>:</h4>
<p>got it now, thank you so much <span class="user-mention" data-user-id="232957">@Jack Huey</span></p>



<a name="245967938"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/impl%20trait%20vs%20explicit%20trait%20bounds/near/245967938" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/impl.20trait.20vs.20explicit.20trait.20bounds.html#245967938">(Jul 14 2021 at 14:31)</a>:</h4>
<p>Of course!</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>